rochars / wavefile

 * Copyright (c) 2017-2019 Rafael da Silva Rocha.

 *

 * Permission is hereby granted, free of charge, to any person obtaining

 * a copy of this software and associated documentation files (the

 * "Software"), to deal in the Software without restriction, including

 * without limitation the rights to use, copy, modify, merge, publish,

 * distribute, sublicense, and/or sell copies of the Software, and to

 * permit persons to whom the Software is furnished to do so, subject to

 * the following conditions:

 *

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 *

 */

/**

 * @fileoverview The WaveFileCreator class.

 * @see https://github.com/rochars/wavefile

 */

/** @module wavefile */

import WaveFileParser from './wavefile-parser';

import interleave from './interleave';

import dwChannelMask from './dw-channel-mask';

import {packArrayTo} from 'byte-data';

/**

 * A class to read, write and create wav files.

 * @extends WaveFileParser

 */

export default class WaveFileCreator extends WaveFileParser {

  /**

   * Set up the WaveFileCreator object based on the arguments passed.

   * @param {number} numChannels The number of channels

   *    (Integer numbers: 1 for mono, 2 stereo and so on).

   * @param {number} sampleRate The sample rate.

   *    Integer numbers like 8000, 44100, 48000, 96000, 192000.

   * @param {string} bitDepthCode The audio bit depth code.

   *    One of '4', '8', '8a', '8m', '16', '24', '32', '32f', '64'

   *    or any value between '8' and '32' (like '12').

   * @param {!Array<number>|!Array<!Array<number>>|!TypedArray} samples

   *    The samples. Must be in the correct range according to the bit depth.

   * @param {?Object} options Optional. Used to force the container

   *    as RIFX with {'container': 'RIFX'}

   * @throws {Error} If any argument does not meet the criteria.

   */

  fromScratch(numChannels, sampleRate, bitDepthCode, samples, options={}) {

    if (!options.container) {

      options.container = 'RIFF';

    }

    this.container = options.container;

    this.bitDepth = bitDepthCode;

    samples = interleave(samples);

    this.updateDataType();

    /** @type {number} */

    let numBytes = this.dataType.bits / 8;

    this.data.samples = new Uint8Array(samples.length * numBytes);

    packArrayTo(samples, this.dataType, this.data.samples);

    this.clearHeader();

    this.makeWavHeader_(

      bitDepthCode, numChannels, sampleRate,

      numBytes, this.data.samples.length, options);

    this.data.chunkId = 'data';

    this.data.chunkSize = this.data.samples.length;

    this.validateWavHeader();

  }

  /**

   * Define the header of a wav file.

   * @param {string} bitDepthCode The audio bit depth

   * @param {number} numChannels The number of channels

   * @param {number} sampleRate The sample rate.

   * @param {number} numBytes The number of bytes each sample use.

   * @param {number} samplesLength The length of the samples in bytes.

   * @param {!Object} options The extra options, like container defintion.

   * @private

   */

  makeWavHeader_(

    bitDepthCode, numChannels, sampleRate, numBytes, samplesLength, options) {

    if (bitDepthCode == '4') {

      this.createADPCMHeader_(

        bitDepthCode, numChannels, sampleRate, numBytes, samplesLength, options);

    } else if (bitDepthCode == '8a' || bitDepthCode == '8m') {

      this.createALawMulawHeader_(

        bitDepthCode, numChannels, sampleRate, numBytes, samplesLength, options);

    } else if(Object.keys(this.WAV_AUDIO_FORMATS).indexOf(bitDepthCode) == -1 ||

        numChannels > 2) {

      this.createExtensibleHeader_(

        bitDepthCode, numChannels, sampleRate, numBytes, samplesLength, options);

    } else {

      this.createPCMHeader_(

        bitDepthCode, numChannels, sampleRate, numBytes, samplesLength, options);      

    }

  }

  /**

   * Create the header of a linear PCM wave file.

   * @param {string} bitDepthCode The audio bit depth

   * @param {number} numChannels The number of channels

   * @param {number} sampleRate The sample rate.

   * @param {number} numBytes The number of bytes each sample use.

   * @param {number} samplesLength The length of the samples in bytes.

   * @param {!Object} options The extra options, like container defintion.

   * @private

   */

  createPCMHeader_(

    bitDepthCode, numChannels, sampleRate, numBytes, samplesLength, options) {

    this.container = options.container;

    this.chunkSize = 36 + samplesLength;

    this.format = 'WAVE';

    this.bitDepth = bitDepthCode;

    this.fmt = {

      chunkId: 'fmt ',

      chunkSize: 16,

      audioFormat: this.WAV_AUDIO_FORMATS[bitDepthCode] || 65534,

      numChannels: numChannels,

      sampleRate: sampleRate,

      byteRate: (numChannels * numBytes) * sampleRate,

      blockAlign: numChannels * numBytes,

      bitsPerSample: parseInt(bitDepthCode, 10),

      cbSize: 0,

      validBitsPerSample: 0,

      dwChannelMask: 0,

      subformat: []

    };

  }

  /**

   * Create the header of a ADPCM wave file.

   * @param {string} bitDepthCode The audio bit depth

   * @param {number} numChannels The number of channels

   * @param {number} sampleRate The sample rate.

   * @param {number} numBytes The number of bytes each sample use.

   * @param {number} samplesLength The length of the samples in bytes.

   * @param {!Object} options The extra options, like container defintion.

   * @private

   */

  createADPCMHeader_(

  /**

   * Create the header of WAVE_FORMAT_EXTENSIBLE file.

   * @param {string} bitDepthCode The audio bit depth

   * @param {number} numChannels The number of channels

   * @param {number} sampleRate The sample rate.

   * @param {number} numBytes The number of bytes each sample use.

   * @param {number} samplesLength The length of the samples in bytes.

   * @param {!Object} options The extra options, like container defintion.

   * @private

   */

  createExtensibleHeader_(

      bitDepthCode, numChannels, sampleRate, numBytes, samplesLength, options) {

    this.createPCMHeader_(

      bitDepthCode, numChannels, sampleRate, numBytes, samplesLength, options);

    this.chunkSize = 36 + 24 + samplesLength;

    this.fmt.chunkSize = 40;

    this.fmt.bitsPerSample = ((parseInt(bitDepthCode, 10) - 1) | 7) + 1;

    this.fmt.cbSize = 22;

    this.fmt.validBitsPerSample = parseInt(bitDepthCode, 10);

    this.fmt.dwChannelMask = dwChannelMask(numChannels);

    // subformat 128-bit GUID as 4 32-bit values

    // only supports uncompressed integer PCM samples

    this.fmt.subformat = [1, 1048576, 2852126848, 1905997824];

  }

  /**

   * Create the header of mu-Law and A-Law wave files.

   * @param {string} bitDepthCode The audio bit depth

   * @param {number} numChannels The number of channels

   * @param {number} sampleRate The sample rate.

   * @param {number} numBytes The number of bytes each sample use.

   * @param {number} samplesLength The length of the samples in bytes.

   * @param {!Object} options The extra options, like container defintion.

   * @private

   */

  createALawMulawHeader_(

      bitDepthCode, numChannels, sampleRate, numBytes, samplesLength, options) {

    this.createPCMHeader_(

      bitDepthCode, numChannels, sampleRate, numBytes, samplesLength, options);

    this.chunkSize = 40 + samplesLength;

    this.fmt.chunkSize = 20;

    this.fmt.cbSize = 2;

    this.fmt.validBitsPerSample = 8;

    this.fact = {

      chunkId: 'fact',

      chunkSize: 4,

      dwSampleLength: samplesLength

    };

  }

}